import * as THREE from 'three';

export default class ColladaLoader extends THREE.Loader {

    constructor( manager ) {

        super( manager );

    }

    load( url, onLoad, onProgress, onError ) {

        const scope = this;
        const path = scope.path === '' ? THREE.LoaderUtils.extractUrlBase( url ) : scope.path;
        const loader = new THREE.FileLoader( scope.manager );
        loader.setPath( scope.path );
        loader.setRequestHeader( scope.requestHeader );
        loader.setWithCredentials( scope.withCredentials );
        loader.load( url, function ( text ) {

            try {

                onLoad( scope.parse( text, path ) );

            } catch ( e ) {

                if ( onError ) {

                    onError( e );

                } else {

                    console.error( e );

                }

                scope.manager.itemError( url );

            }

        }, onProgress, onError );

    }

    parse( text, path ) {

        function getElementsByTagName( xml, name ) {

            // Non recursive xml.getElementsByTagName() ...
            const array = [];
            const childNodes = xml.childNodes;

            for ( let i = 0, l = childNodes.length; i < l; i ++ ) {

                const child = childNodes[ i ];

                if ( child.nodeName === name ) {

                    array.push( child );

                }

            }

            return array;

        }

        function parseStrings( text ) {

            if ( text.length === 0 ) return [];
            const parts = text.trim().split( /\s+/ );
            const array = new Array( parts.length );

            for ( let i = 0, l = parts.length; i < l; i ++ ) {

                array[ i ] = parts[ i ];

            }

            return array;

        }

        function parseFloats( text ) {

            if ( text.length === 0 ) return [];
            const parts = text.trim().split( /\s+/ );
            const array = new Array( parts.length );

            for ( let i = 0, l = parts.length; i < l; i ++ ) {

                array[ i ] = parseFloat( parts[ i ] );

            }

            return array;

        }

        function parseInts( text ) {

            if ( text.length === 0 ) return [];
            const parts = text.trim().split( /\s+/ );
            const array = new Array( parts.length );

            for ( let i = 0, l = parts.length; i < l; i ++ ) {

                array[ i ] = parseInt( parts[ i ] );

            }

            return array;

        }

        function parseId( text ) {

            return text.substring( 1 );

        }

        function generateId() {

            return 'three_default_' + count ++;

        }

        function isEmpty( object ) {

            return Object.keys( object ).length === 0;

        } // asset


        function parseAsset( xml ) {

            return {
                unit: parseAssetUnit( getElementsByTagName( xml, 'unit' )[ 0 ] ),
                upAxis: parseAssetUpAxis( getElementsByTagName( xml, 'up_axis' )[ 0 ] )
            };

        }

        function parseAssetUnit( xml ) {

            if ( xml !== undefined && xml.hasAttribute( 'meter' ) === true ) {

                return parseFloat( xml.getAttribute( 'meter' ) );

            } else {

                return 1; // default 1 meter

            }

        }

        function parseAssetUpAxis( xml ) {

            return xml !== undefined ? xml.textContent : 'Y_UP';

        } // library


        function parseLibrary( xml, libraryName, nodeName, parser ) {

            const library = getElementsByTagName( xml, libraryName )[ 0 ];

            if ( library !== undefined ) {

                const elements = getElementsByTagName( library, nodeName );

                for ( let i = 0; i < elements.length; i ++ ) {

                    parser( elements[ i ] );

                }

            }

        }

        function buildLibrary( data, builder ) {

            for ( const name in data ) {

                const object = data[ name ];
                object.build = builder( data[ name ] );

            }

        } // get


        function getBuild( data, builder ) {

            if ( data.build !== undefined ) return data.build;
            data.build = builder( data );
            return data.build;

        } // animation


        function parseAnimation( xml ) {

            const data = {
                sources: {},
                samplers: {},
                channels: {}
            };
            let hasChildren = false;

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;
                let id;

                switch ( child.nodeName ) {

                    case 'source':
                        id = child.getAttribute( 'id' );
                        data.sources[ id ] = parseSource( child );
                        break;

                    case 'sampler':
                        id = child.getAttribute( 'id' );
                        data.samplers[ id ] = parseAnimationSampler( child );
                        break;

                    case 'channel':
                        id = child.getAttribute( 'target' );
                        data.channels[ id ] = parseAnimationChannel( child );
                        break;

                    case 'animation':
                        // hierarchy of related animations
                        parseAnimation( child );
                        hasChildren = true;
                        break;

                    default:
                        console.log( child );

                }

            }

            if ( hasChildren === false ) {

                // since 'id' attributes can be optional, it's necessary to generate a UUID for unqiue assignment
                library.animations[ xml.getAttribute( 'id' ) || THREE.MathUtils.generateUUID() ] = data;

            }

        }

        function parseAnimationSampler( xml ) {

            const data = {
                inputs: {}
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'input':
                        const id = parseId( child.getAttribute( 'source' ) );
                        const semantic = child.getAttribute( 'semantic' );
                        data.inputs[ semantic ] = id;
                        break;

                }

            }

            return data;

        }

        function parseAnimationChannel( xml ) {

            const data = {};
            const target = xml.getAttribute( 'target' ); // parsing SID Addressing Syntax

            let parts = target.split( '/' );
            const id = parts.shift();
            let sid = parts.shift(); // check selection syntax

            const arraySyntax = sid.indexOf( '(' ) !== - 1;
            const memberSyntax = sid.indexOf( '.' ) !== - 1;

            if ( memberSyntax ) {

                //  member selection access
                parts = sid.split( '.' );
                sid = parts.shift();
                data.member = parts.shift();

            } else if ( arraySyntax ) {

                // array-access syntax. can be used to express fields in one-dimensional vectors or two-dimensional matrices.
                const indices = sid.split( '(' );
                sid = indices.shift();

                for ( let i = 0; i < indices.length; i ++ ) {

                    indices[ i ] = parseInt( indices[ i ].replace( /\)/, '' ) );

                }

                data.indices = indices;

            }

            data.id = id;
            data.sid = sid;
            data.arraySyntax = arraySyntax;
            data.memberSyntax = memberSyntax;
            data.sampler = parseId( xml.getAttribute( 'source' ) );
            return data;

        }

        function buildAnimation( data ) {

            const tracks = [];
            const channels = data.channels;
            const samplers = data.samplers;
            const sources = data.sources;

            for ( const target in channels ) {

                if ( channels.hasOwnProperty( target ) ) {

                    const channel = channels[ target ];
                    const sampler = samplers[ channel.sampler ];
                    const inputId = sampler.inputs.INPUT;
                    const outputId = sampler.inputs.OUTPUT;
                    const inputSource = sources[ inputId ];
                    const outputSource = sources[ outputId ];
                    const animation = buildAnimationChannel( channel, inputSource, outputSource );
                    createKeyframeTracks( animation, tracks );

                }

            }

            return tracks;

        }

        function getAnimation( id ) {

            return getBuild( library.animations[ id ], buildAnimation );

        }

        function buildAnimationChannel( channel, inputSource, outputSource ) {

            const node = library.nodes[ channel.id ];
            const object3D = getNode( node.id );
            const transform = node.transforms[ channel.sid ];
            const defaultMatrix = node.matrix.clone().transpose();
            let time, stride;
            let i, il, j, jl;
            const data = {}; // the collada spec allows the animation of data in various ways.
            // depending on the transform type (matrix, translate, rotate, scale), we execute different logic

            switch ( transform ) {

                case 'matrix':
                    for ( i = 0, il = inputSource.array.length; i < il; i ++ ) {

                        time = inputSource.array[ i ];
                        stride = i * outputSource.stride;
                        if ( data[ time ] === undefined ) data[ time ] = {};

                        if ( channel.arraySyntax === true ) {

                            const value = outputSource.array[ stride ];
                            const index = channel.indices[ 0 ] + 4 * channel.indices[ 1 ];
                            data[ time ][ index ] = value;

                        } else {

                            for ( j = 0, jl = outputSource.stride; j < jl; j ++ ) {

                                data[ time ][ j ] = outputSource.array[ stride + j ];

                            }

                        }

                    }

                    break;

                case 'translate':
                    console.warn( 'THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform );
                    break;

                case 'rotate':
                    console.warn( 'THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform );
                    break;

                case 'scale':
                    console.warn( 'THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform );
                    break;

            }

            const keyframes = prepareAnimationData( data, defaultMatrix );
            const animation = {
                name: object3D.uuid,
                keyframes: keyframes
            };
            return animation;

        }

        function prepareAnimationData( data, defaultMatrix ) {

            const keyframes = []; // transfer data into a sortable array

            for ( const time in data ) {

                keyframes.push( {
                    time: parseFloat( time ),
                    value: data[ time ]
                } );

            } // ensure keyframes are sorted by time


            keyframes.sort( ascending ); // now we clean up all animation data, so we can use them for keyframe tracks

            for ( let i = 0; i < 16; i ++ ) {

                transformAnimationData( keyframes, i, defaultMatrix.elements[ i ] );

            }

            return keyframes; // array sort function

            function ascending( a, b ) {

                return a.time - b.time;

            }

        }

        const position = new THREE.Vector3();
        const scale = new THREE.Vector3();
        const quaternion = new THREE.Quaternion();

        function createKeyframeTracks( animation, tracks ) {

            const keyframes = animation.keyframes;
            const name = animation.name;
            const times = [];
            const positionData = [];
            const quaternionData = [];
            const scaleData = [];

            for ( let i = 0, l = keyframes.length; i < l; i ++ ) {

                const keyframe = keyframes[ i ];
                const time = keyframe.time;
                const value = keyframe.value;
                matrix.fromArray( value ).transpose();
                matrix.decompose( position, quaternion, scale );
                times.push( time );
                positionData.push( position.x, position.y, position.z );
                quaternionData.push( quaternion.x, quaternion.y, quaternion.z, quaternion.w );
                scaleData.push( scale.x, scale.y, scale.z );

            }

            if ( positionData.length > 0 ) tracks.push( new THREE.VectorKeyframeTrack( name + '.position', times, positionData ) );
            if ( quaternionData.length > 0 ) tracks.push( new THREE.QuaternionKeyframeTrack( name + '.quaternion', times, quaternionData ) );
            if ( scaleData.length > 0 ) tracks.push( new THREE.VectorKeyframeTrack( name + '.scale', times, scaleData ) );
            return tracks;

        }

        function transformAnimationData( keyframes, property, defaultValue ) {

            let keyframe;
            let empty = true;
            let i, l; // check, if values of a property are missing in our keyframes

            for ( i = 0, l = keyframes.length; i < l; i ++ ) {

                keyframe = keyframes[ i ];

                if ( keyframe.value[ property ] === undefined ) {

                    keyframe.value[ property ] = null; // mark as missing

                } else {

                    empty = false;

                }

            }

            if ( empty === true ) {

                // no values at all, so we set a default value
                for ( i = 0, l = keyframes.length; i < l; i ++ ) {

                    keyframe = keyframes[ i ];
                    keyframe.value[ property ] = defaultValue;

                }

            } else {

                // filling gaps
                createMissingKeyframes( keyframes, property );

            }

        }

        function createMissingKeyframes( keyframes, property ) {

            let prev, next;

            for ( let i = 0, l = keyframes.length; i < l; i ++ ) {

                const keyframe = keyframes[ i ];

                if ( keyframe.value[ property ] === null ) {

                    prev = getPrev( keyframes, i, property );
                    next = getNext( keyframes, i, property );

                    if ( prev === null ) {

                        keyframe.value[ property ] = next.value[ property ];
                        continue;

                    }

                    if ( next === null ) {

                        keyframe.value[ property ] = prev.value[ property ];
                        continue;

                    }

                    interpolate( keyframe, prev, next, property );

                }

            }

        }

        function getPrev( keyframes, i, property ) {

            while ( i >= 0 ) {

                const keyframe = keyframes[ i ];
                if ( keyframe.value[ property ] !== null ) return keyframe;
                i --;

            }

            return null;

        }

        function getNext( keyframes, i, property ) {

            while ( i < keyframes.length ) {

                const keyframe = keyframes[ i ];
                if ( keyframe.value[ property ] !== null ) return keyframe;
                i ++;

            }

            return null;

        }

        function interpolate( key, prev, next, property ) {

            if ( next.time - prev.time === 0 ) {

                key.value[ property ] = prev.value[ property ];
                return;

            }

            key.value[ property ] = ( key.time - prev.time ) * ( next.value[ property ] - prev.value[ property ] ) / ( next.time - prev.time ) + prev.value[ property ];

        } // animation clips


        function parseAnimationClip( xml ) {

            const data = {
                name: xml.getAttribute( 'id' ) || 'default',
                start: parseFloat( xml.getAttribute( 'start' ) || 0 ),
                end: parseFloat( xml.getAttribute( 'end' ) || 0 ),
                animations: []
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'instance_animation':
                        data.animations.push( parseId( child.getAttribute( 'url' ) ) );
                        break;

                }

            }

            library.clips[ xml.getAttribute( 'id' ) ] = data;

        }

        function buildAnimationClip( data ) {

            const tracks = [];
            const name = data.name;
            const duration = data.end - data.start || - 1;
            const animations = data.animations;

            for ( let i = 0, il = animations.length; i < il; i ++ ) {

                const animationTracks = getAnimation( animations[ i ] );

                for ( let j = 0, jl = animationTracks.length; j < jl; j ++ ) {

                    tracks.push( animationTracks[ j ] );

                }

            }

            return new THREE.AnimationClip( name, duration, tracks );

        }

        function getAnimationClip( id ) {

            return getBuild( library.clips[ id ], buildAnimationClip );

        } // controller


        function parseController( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'skin':
                        // there is exactly one skin per controller
                        data.id = parseId( child.getAttribute( 'source' ) );
                        data.skin = parseSkin( child );
                        break;

                    case 'morph':
                        data.id = parseId( child.getAttribute( 'source' ) );
                        console.warn( 'THREE.ColladaLoader: Morph target animation not supported yet.' );
                        break;

                }

            }

            library.controllers[ xml.getAttribute( 'id' ) ] = data;

        }

        function parseSkin( xml ) {

            const data = {
                sources: {}
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'bind_shape_matrix':
                        data.bindShapeMatrix = parseFloats( child.textContent );
                        break;

                    case 'source':
                        const id = child.getAttribute( 'id' );
                        data.sources[ id ] = parseSource( child );
                        break;

                    case 'joints':
                        data.joints = parseJoints( child );
                        break;

                    case 'vertex_weights':
                        data.vertexWeights = parseVertexWeights( child );
                        break;

                }

            }

            return data;

        }

        function parseJoints( xml ) {

            const data = {
                inputs: {}
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'input':
                        const semantic = child.getAttribute( 'semantic' );
                        const id = parseId( child.getAttribute( 'source' ) );
                        data.inputs[ semantic ] = id;
                        break;

                }

            }

            return data;

        }

        function parseVertexWeights( xml ) {

            const data = {
                inputs: {}
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'input':
                        const semantic = child.getAttribute( 'semantic' );
                        const id = parseId( child.getAttribute( 'source' ) );
                        const offset = parseInt( child.getAttribute( 'offset' ) );
                        data.inputs[ semantic ] = {
                            id: id,
                            offset: offset
                        };
                        break;

                    case 'vcount':
                        data.vcount = parseInts( child.textContent );
                        break;

                    case 'v':
                        data.v = parseInts( child.textContent );
                        break;

                }

            }

            return data;

        }

        function buildController( data ) {

            const build = {
                id: data.id
            };
            const geometry = library.geometries[ build.id ];

            if ( data.skin !== undefined ) {

                build.skin = buildSkin( data.skin ); // we enhance the 'sources' property of the corresponding geometry with our skin data

                geometry.sources.skinIndices = build.skin.indices;
                geometry.sources.skinWeights = build.skin.weights;

            }

            return build;

        }

        function buildSkin( data ) {

            const BONE_LIMIT = 4;
            const build = {
                joints: [],
                // this must be an array to preserve the joint order
                indices: {
                    array: [],
                    stride: BONE_LIMIT
                },
                weights: {
                    array: [],
                    stride: BONE_LIMIT
                }
            };
            const sources = data.sources;
            const vertexWeights = data.vertexWeights;
            const vcount = vertexWeights.vcount;
            const v = vertexWeights.v;
            const jointOffset = vertexWeights.inputs.JOINT.offset;
            const weightOffset = vertexWeights.inputs.WEIGHT.offset;
            const jointSource = data.sources[ data.joints.inputs.JOINT ];
            const inverseSource = data.sources[ data.joints.inputs.INV_BIND_MATRIX ];
            const weights = sources[ vertexWeights.inputs.WEIGHT.id ].array;
            let stride = 0;
            let i, j, l; // procces skin data for each vertex

            for ( i = 0, l = vcount.length; i < l; i ++ ) {

                const jointCount = vcount[ i ]; // this is the amount of joints that affect a single vertex

                const vertexSkinData = [];

                for ( j = 0; j < jointCount; j ++ ) {

                    const skinIndex = v[ stride + jointOffset ];
                    const weightId = v[ stride + weightOffset ];
                    const skinWeight = weights[ weightId ];
                    vertexSkinData.push( {
                        index: skinIndex,
                        weight: skinWeight
                    } );
                    stride += 2;

                } // we sort the joints in descending order based on the weights.
                // this ensures, we only procced the most important joints of the vertex


                vertexSkinData.sort( descending ); // now we provide for each vertex a set of four index and weight values.
                // the order of the skin data matches the order of vertices

                for ( j = 0; j < BONE_LIMIT; j ++ ) {

                    const d = vertexSkinData[ j ];

                    if ( d !== undefined ) {

                        build.indices.array.push( d.index );
                        build.weights.array.push( d.weight );

                    } else {

                        build.indices.array.push( 0 );
                        build.weights.array.push( 0 );

                    }

                }

            } // setup bind matrix


            if ( data.bindShapeMatrix ) {

                build.bindMatrix = new THREE.Matrix4().fromArray( data.bindShapeMatrix ).transpose();

            } else {

                build.bindMatrix = new THREE.Matrix4().identity();

            } // process bones and inverse bind matrix data


            for ( i = 0, l = jointSource.array.length; i < l; i ++ ) {

                const name = jointSource.array[ i ];
                const boneInverse = new THREE.Matrix4().fromArray( inverseSource.array, i * inverseSource.stride ).transpose();
                build.joints.push( {
                    name: name,
                    boneInverse: boneInverse
                } );

            }

            return build; // array sort function

            function descending( a, b ) {

                return b.weight - a.weight;

            }

        }

        function getController( id ) {

            return getBuild( library.controllers[ id ], buildController );

        } // image


        function parseImage( xml ) {

            const data = {
                init_from: getElementsByTagName( xml, 'init_from' )[ 0 ].textContent
            };
            library.images[ xml.getAttribute( 'id' ) ] = data;

        }

        function buildImage( data ) {

            if ( data.build !== undefined ) return data.build;
            return data.init_from;

        }

        function getImage( id ) {

            const data = library.images[ id ];

            if ( data !== undefined ) {

                return getBuild( data, buildImage );

            }

            console.warn( 'THREE.ColladaLoader: Couldn\'t find image with ID:', id );
            return null;

        } // effect


        function parseEffect( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'profile_COMMON':
                        data.profile = parseEffectProfileCOMMON( child );
                        break;

                }

            }

            library.effects[ xml.getAttribute( 'id' ) ] = data;

        }

        function parseEffectProfileCOMMON( xml ) {

            const data = {
                surfaces: {},
                samplers: {}
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'newparam':
                        parseEffectNewparam( child, data );
                        break;

                    case 'technique':
                        data.technique = parseEffectTechnique( child );
                        break;

                    case 'extra':
                        data.extra = parseEffectExtra( child );
                        break;

                }

            }

            return data;

        }

        function parseEffectNewparam( xml, data ) {

            const sid = xml.getAttribute( 'sid' );

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'surface':
                        data.surfaces[ sid ] = parseEffectSurface( child );
                        break;

                    case 'sampler2D':
                        data.samplers[ sid ] = parseEffectSampler( child );
                        break;

                }

            }

        }

        function parseEffectSurface( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'init_from':
                        data.init_from = child.textContent;
                        break;

                }

            }

            return data;

        }

        function parseEffectSampler( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'source':
                        data.source = child.textContent;
                        break;

                }

            }

            return data;

        }

        function parseEffectTechnique( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'constant':
                    case 'lambert':
                    case 'blinn':
                    case 'phong':
                        data.type = child.nodeName;
                        data.parameters = parseEffectParameters( child );
                        break;

                    case 'extra':
                        data.extra = parseEffectExtra( child );
                        break;

                }

            }

            return data;

        }

        function parseEffectParameters( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'emission':
                    case 'diffuse':
                    case 'specular':
                    case 'bump':
                    case 'ambient':
                    case 'shininess':
                    case 'transparency':
                        data[ child.nodeName ] = parseEffectParameter( child );
                        break;

                    case 'transparent':
                        data[ child.nodeName ] = {
                            opaque: child.hasAttribute( 'opaque' ) ? child.getAttribute( 'opaque' ) : 'A_ONE',
                            data: parseEffectParameter( child )
                        };
                        break;

                }

            }

            return data;

        }

        function parseEffectParameter( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'color':
                        data[ child.nodeName ] = parseFloats( child.textContent );
                        break;

                    case 'float':
                        data[ child.nodeName ] = parseFloat( child.textContent );
                        break;

                    case 'texture':
                        data[ child.nodeName ] = {
                            id: child.getAttribute( 'texture' ),
                            extra: parseEffectParameterTexture( child )
                        };
                        break;

                }

            }

            return data;

        }

        function parseEffectParameterTexture( xml ) {

            const data = {
                technique: {}
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'extra':
                        parseEffectParameterTextureExtra( child, data );
                        break;

                }

            }

            return data;

        }

        function parseEffectParameterTextureExtra( xml, data ) {

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'technique':
                        parseEffectParameterTextureExtraTechnique( child, data );
                        break;

                }

            }

        }

        function parseEffectParameterTextureExtraTechnique( xml, data ) {

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'repeatU':
                    case 'repeatV':
                    case 'offsetU':
                    case 'offsetV':
                        data.technique[ child.nodeName ] = parseFloat( child.textContent );
                        break;

                    case 'wrapU':
                    case 'wrapV':
                        // some files have values for wrapU/wrapV which become NaN via parseInt
                        if ( child.textContent.toUpperCase() === 'TRUE' ) {

                            data.technique[ child.nodeName ] = 1;

                        } else if ( child.textContent.toUpperCase() === 'FALSE' ) {

                            data.technique[ child.nodeName ] = 0;

                        } else {

                            data.technique[ child.nodeName ] = parseInt( child.textContent );

                        }

                        break;

                    case 'bump':
                        data[ child.nodeName ] = parseEffectExtraTechniqueBump( child );
                        break;

                }

            }

        }

        function parseEffectExtra( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'technique':
                        data.technique = parseEffectExtraTechnique( child );
                        break;

                }

            }

            return data;

        }

        function parseEffectExtraTechnique( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'double_sided':
                        data[ child.nodeName ] = parseInt( child.textContent );
                        break;

                    case 'bump':
                        data[ child.nodeName ] = parseEffectExtraTechniqueBump( child );
                        break;

                }

            }

            return data;

        }

        function parseEffectExtraTechniqueBump( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'texture':
                        data[ child.nodeName ] = {
                            id: child.getAttribute( 'texture' ),
                            texcoord: child.getAttribute( 'texcoord' ),
                            extra: parseEffectParameterTexture( child )
                        };
                        break;

                }

            }

            return data;

        }

        function buildEffect( data ) {

            return data;

        }

        function getEffect( id ) {

            return getBuild( library.effects[ id ], buildEffect );

        } // material


        function parseMaterial( xml ) {

            const data = {
                name: xml.getAttribute( 'name' )
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'instance_effect':
                        data.url = parseId( child.getAttribute( 'url' ) );
                        break;

                }

            }

            library.materials[ xml.getAttribute( 'id' ) ] = data;

        }

        function getTextureLoader( image ) {

            let loader;
            let extension = image.slice( ( image.lastIndexOf( '.' ) - 1 >>> 0 ) + 2 ); // http://www.jstips.co/en/javascript/get-file-extension/

            extension = extension.toLowerCase();

            switch ( extension ) {

                case 'tga':
                    loader = tgaLoader;
                    break;

                default:
                    loader = textureLoader;

            }

            return loader;

        }

        function buildMaterial( data ) {

            const effect = getEffect( data.url );
            const technique = effect.profile.technique;
            let material;

            switch ( technique.type ) {

                case 'phong':
                case 'blinn':
                    material = new THREE.MeshPhongMaterial();
                    break;

                case 'lambert':
                    material = new THREE.MeshLambertMaterial();
                    break;

                default:
                    material = new THREE.MeshBasicMaterial();
                    break;

            }

            material.name = data.name || '';

            function getTexture( textureObject, encoding = null ) {

                const sampler = effect.profile.samplers[ textureObject.id ];
                let image = null; // get image

                if ( sampler !== undefined ) {

                    const surface = effect.profile.surfaces[ sampler.source ];
                    image = getImage( surface.init_from );

                } else {

                    console.warn( 'THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530).' );
                    image = getImage( textureObject.id );

                } // create texture if image is avaiable


                if ( image !== null ) {

                    const loader = getTextureLoader( image );

                    if ( loader !== undefined ) {

                        const texture = loader.load( image );
                        const extra = textureObject.extra;

                        if ( extra !== undefined && extra.technique !== undefined && isEmpty( extra.technique ) === false ) {

                            const technique = extra.technique;
                            texture.wrapS = technique.wrapU ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
                            texture.wrapT = technique.wrapV ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
                            texture.offset.set( technique.offsetU || 0, technique.offsetV || 0 );
                            texture.repeat.set( technique.repeatU || 1, technique.repeatV || 1 );

                        } else {

                            texture.wrapS = THREE.RepeatWrapping;
                            texture.wrapT = THREE.RepeatWrapping;

                        }

                        if ( encoding !== null ) {

                            texture.encoding = encoding;

                        }

                        return texture;

                    } else {

                        console.warn( 'THREE.ColladaLoader: THREE.Loader for texture %s not found.', image );
                        return null;

                    }

                } else {

                    console.warn( 'THREE.ColladaLoader: Couldn\'t create texture with ID:', textureObject.id );
                    return null;

                }

            }

            const parameters = technique.parameters;

            for ( const key in parameters ) {

                const parameter = parameters[ key ];

                switch ( key ) {

                    case 'diffuse':
                        if ( parameter.color ) material.color.fromArray( parameter.color );
                        if ( parameter.texture ) material.map = getTexture( parameter.texture, THREE.sRGBEncoding );
                        break;

                    case 'specular':
                        if ( parameter.color && material.specular ) material.specular.fromArray( parameter.color );
                        if ( parameter.texture ) material.specularMap = getTexture( parameter.texture );
                        break;

                    case 'bump':
                        if ( parameter.texture ) material.normalMap = getTexture( parameter.texture );
                        break;

                    case 'ambient':
                        if ( parameter.texture ) material.lightMap = getTexture( parameter.texture, THREE.sRGBEncoding );
                        break;

                    case 'shininess':
                        if ( parameter.float && material.shininess ) material.shininess = parameter.float;
                        break;

                    case 'emission':
                        if ( parameter.color && material.emissive ) material.emissive.fromArray( parameter.color );
                        if ( parameter.texture ) material.emissiveMap = getTexture( parameter.texture, THREE.sRGBEncoding );
                        break;

                }

            }

            material.color.convertSRGBToLinear();
            if ( material.specular ) material.specular.convertSRGBToLinear();
            if ( material.emissive ) material.emissive.convertSRGBToLinear(); //

            let transparent = parameters[ 'transparent' ];
            let transparency = parameters[ 'transparency' ]; // <transparency> does not exist but <transparent>

            if ( transparency === undefined && transparent ) {

                transparency = {
                    float: 1
                };

            } // <transparent> does not exist but <transparency>


            if ( transparent === undefined && transparency ) {

                transparent = {
                    opaque: 'A_ONE',
                    data: {
                        color: [ 1, 1, 1, 1 ]
                    }
                };

            }

            if ( transparent && transparency ) {

                // handle case if a texture exists but no color
                if ( transparent.data.texture ) {

                    // we do not set an alpha map (see #13792)
                    material.transparent = true;

                } else {

                    const color = transparent.data.color;

                    switch ( transparent.opaque ) {

                        case 'A_ONE':
                            material.opacity = color[ 3 ] * transparency.float;
                            break;

                        case 'RGB_ZERO':
                            material.opacity = 1 - color[ 0 ] * transparency.float;
                            break;

                        case 'A_ZERO':
                            material.opacity = 1 - color[ 3 ] * transparency.float;
                            break;

                        case 'RGB_ONE':
                            material.opacity = color[ 0 ] * transparency.float;
                            break;

                        default:
                            console.warn( 'THREE.ColladaLoader: Invalid opaque type "%s" of transparent tag.', transparent.opaque );

                    }

                    if ( material.opacity < 1 ) material.transparent = true;

                }

            } //


            if ( technique.extra !== undefined && technique.extra.technique !== undefined ) {

                const techniques = technique.extra.technique;

                for ( const k in techniques ) {

                    const v = techniques[ k ];

                    switch ( k ) {

                        case 'double_sided':
                            material.side = v === 1 ? THREE.DoubleSide : THREE.FrontSide;
                            break;

                        case 'bump':
                            material.normalMap = getTexture( v.texture );
                            material.normalScale = new THREE.Vector2( 1, 1 );
                            break;

                    }

                }

            }

            return material;

        }

        function getMaterial( id ) {

            return getBuild( library.materials[ id ], buildMaterial );

        } // camera


        function parseCamera( xml ) {

            const data = {
                name: xml.getAttribute( 'name' )
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'optics':
                        data.optics = parseCameraOptics( child );
                        break;

                }

            }

            library.cameras[ xml.getAttribute( 'id' ) ] = data;

        }

        function parseCameraOptics( xml ) {

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];

                switch ( child.nodeName ) {

                    case 'technique_common':
                        return parseCameraTechnique( child );

                }

            }

            return {};

        }

        function parseCameraTechnique( xml ) {

            const data = {};

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];

                switch ( child.nodeName ) {

                    case 'perspective':
                    case 'orthographic':
                        data.technique = child.nodeName;
                        data.parameters = parseCameraParameters( child );
                        break;

                }

            }

            return data;

        }

        function parseCameraParameters( xml ) {

            const data = {};

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];

                switch ( child.nodeName ) {

                    case 'xfov':
                    case 'yfov':
                    case 'xmag':
                    case 'ymag':
                    case 'znear':
                    case 'zfar':
                    case 'aspect_ratio':
                        data[ child.nodeName ] = parseFloat( child.textContent );
                        break;

                }

            }

            return data;

        }

        function buildCamera( data ) {

            let camera;

            switch ( data.optics.technique ) {

                case 'perspective':
                    camera = new THREE.PerspectiveCamera( data.optics.parameters.yfov, data.optics.parameters.aspect_ratio, data.optics.parameters.znear, data.optics.parameters.zfar );
                    break;

                case 'orthographic':
                    let ymag = data.optics.parameters.ymag;
                    let xmag = data.optics.parameters.xmag;
                    const aspectRatio = data.optics.parameters.aspect_ratio;
                    xmag = xmag === undefined ? ymag * aspectRatio : xmag;
                    ymag = ymag === undefined ? xmag / aspectRatio : ymag;
                    xmag *= 0.5;
                    ymag *= 0.5;
                    camera = new THREE.OrthographicCamera( - xmag, xmag, ymag, - ymag, // left, right, top, bottom
                        data.optics.parameters.znear, data.optics.parameters.zfar );
                    break;

                default:
                    camera = new THREE.PerspectiveCamera();
                    break;

            }

            camera.name = data.name || '';
            return camera;

        }

        function getCamera( id ) {

            const data = library.cameras[ id ];

            if ( data !== undefined ) {

                return getBuild( data, buildCamera );

            }

            console.warn( 'THREE.ColladaLoader: Couldn\'t find camera with ID:', id );
            return null;

        } // light


        function parseLight( xml ) {

            let data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'technique_common':
                        data = parseLightTechnique( child );
                        break;

                }

            }

            library.lights[ xml.getAttribute( 'id' ) ] = data;

        }

        function parseLightTechnique( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'directional':
                    case 'point':
                    case 'spot':
                    case 'ambient':
                        data.technique = child.nodeName;
                        data.parameters = parseLightParameters( child );

                }

            }

            return data;

        }

        function parseLightParameters( xml ) {

            const data = {};

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'color':
                        const array = parseFloats( child.textContent );
                        data.color = new THREE.Color().fromArray( array ).convertSRGBToLinear();
                        break;

                    case 'falloff_angle':
                        data.falloffAngle = parseFloat( child.textContent );
                        break;

                    case 'quadratic_attenuation':
                        const f = parseFloat( child.textContent );
                        data.distance = f ? Math.sqrt( 1 / f ) : 0;
                        break;

                }

            }

            return data;

        }

        function buildLight( data ) {

            let light;

            switch ( data.technique ) {

                case 'directional':
                    light = new THREE.DirectionalLight();
                    break;

                case 'point':
                    light = new THREE.PointLight();
                    break;

                case 'spot':
                    light = new THREE.SpotLight();
                    break;

                case 'ambient':
                    light = new THREE.AmbientLight();
                    break;

            }

            if ( data.parameters.color ) light.color.copy( data.parameters.color );
            if ( data.parameters.distance ) light.distance = data.parameters.distance;
            return light;

        }

        function getLight( id ) {

            const data = library.lights[ id ];

            if ( data !== undefined ) {

                return getBuild( data, buildLight );

            }

            console.warn( 'THREE.ColladaLoader: Couldn\'t find light with ID:', id );
            return null;

        } // geometry


        function parseGeometry( xml ) {

            const data = {
                name: xml.getAttribute( 'name' ),
                sources: {},
                vertices: {},
                primitives: []
            };
            const mesh = getElementsByTagName( xml, 'mesh' )[ 0 ]; // the following tags inside geometry are not supported yet (see https://github.com/mrdoob/three.js/pull/12606): convex_mesh, spline, brep

            if ( mesh === undefined ) return;

            for ( let i = 0; i < mesh.childNodes.length; i ++ ) {

                const child = mesh.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;
                const id = child.getAttribute( 'id' );

                switch ( child.nodeName ) {

                    case 'source':
                        data.sources[ id ] = parseSource( child );
                        break;

                    case 'vertices':
                        // data.sources[ id ] = data.sources[ parseId( getElementsByTagName( child, 'input' )[ 0 ].getAttribute( 'source' ) ) ];
                        data.vertices = parseGeometryVertices( child );
                        break;

                    case 'polygons':
                        console.warn( 'THREE.ColladaLoader: Unsupported primitive type: ', child.nodeName );
                        break;

                    case 'lines':
                    case 'linestrips':
                    case 'polylist':
                    case 'triangles':
                        data.primitives.push( parseGeometryPrimitive( child ) );
                        break;

                    default:
                        console.log( child );

                }

            }

            library.geometries[ xml.getAttribute( 'id' ) ] = data;

        }

        function parseSource( xml ) {

            const data = {
                array: [],
                stride: 3
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'float_array':
                        data.array = parseFloats( child.textContent );
                        break;

                    case 'Name_array':
                        data.array = parseStrings( child.textContent );
                        break;

                    case 'technique_common':
                        const accessor = getElementsByTagName( child, 'accessor' )[ 0 ];

                        if ( accessor !== undefined ) {

                            data.stride = parseInt( accessor.getAttribute( 'stride' ) );

                        }

                        break;

                }

            }

            return data;

        }

        function parseGeometryVertices( xml ) {

            const data = {};

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;
                data[ child.getAttribute( 'semantic' ) ] = parseId( child.getAttribute( 'source' ) );

            }

            return data;

        }

        function parseGeometryPrimitive( xml ) {

            const primitive = {
                type: xml.nodeName,
                material: xml.getAttribute( 'material' ),
                count: parseInt( xml.getAttribute( 'count' ) ),
                inputs: {},
                stride: 0,
                hasUV: false
            };

            for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'input':
                        const id = parseId( child.getAttribute( 'source' ) );
                        const semantic = child.getAttribute( 'semantic' );
                        const offset = parseInt( child.getAttribute( 'offset' ) );
                        const set = parseInt( child.getAttribute( 'set' ) );
                        const inputname = set > 0 ? semantic + set : semantic;
                        primitive.inputs[ inputname ] = {
                            id: id,
                            offset: offset
                        };
                        primitive.stride = Math.max( primitive.stride, offset + 1 );
                        if ( semantic === 'TEXCOORD' ) primitive.hasUV = true;
                        break;

                    case 'vcount':
                        primitive.vcount = parseInts( child.textContent );
                        break;

                    case 'p':
                        primitive.p = parseInts( child.textContent );
                        break;

                }

            }

            return primitive;

        }

        function groupPrimitives( primitives ) {

            const build = {};

            for ( let i = 0; i < primitives.length; i ++ ) {

                const primitive = primitives[ i ];
                if ( build[ primitive.type ] === undefined ) build[ primitive.type ] = [];
                build[ primitive.type ].push( primitive );

            }

            return build;

        }

        function checkUVCoordinates( primitives ) {

            let count = 0;

            for ( let i = 0, l = primitives.length; i < l; i ++ ) {

                const primitive = primitives[ i ];

                if ( primitive.hasUV === true ) {

                    count ++;

                }

            }

            if ( count > 0 && count < primitives.length ) {

                primitives.uvsNeedsFix = true;

            }

        }

        function buildGeometry( data ) {

            const build = {};
            const sources = data.sources;
            const vertices = data.vertices;
            const primitives = data.primitives;
            if ( primitives.length === 0 ) return {}; // our goal is to create one buffer geometry for a single type of primitives
            // first, we group all primitives by their type

            const groupedPrimitives = groupPrimitives( primitives );

            for ( const type in groupedPrimitives ) {

                const primitiveType = groupedPrimitives[ type ]; // second, ensure consistent uv coordinates for each type of primitives (polylist,triangles or lines)

                checkUVCoordinates( primitiveType ); // third, create a buffer geometry for each type of primitives

                build[ type ] = buildGeometryType( primitiveType, sources, vertices );

            }

            return build;

        }

        function buildGeometryType( primitives, sources, vertices ) {

            const build = {};
            const position = {
                array: [],
                stride: 0
            };
            const normal = {
                array: [],
                stride: 0
            };
            const uv = {
                array: [],
                stride: 0
            };
            const uv2 = {
                array: [],
                stride: 0
            };
            const color = {
                array: [],
                stride: 0
            };
            const skinIndex = {
                array: [],
                stride: 4
            };
            const skinWeight = {
                array: [],
                stride: 4
            };
            const geometry = new THREE.BufferGeometry();
            const materialKeys = [];
            let start = 0;

            for ( let p = 0; p < primitives.length; p ++ ) {

                const primitive = primitives[ p ];
                const inputs = primitive.inputs; // groups

                let count = 0;

                switch ( primitive.type ) {

                    case 'lines':
                    case 'linestrips':
                        count = primitive.count * 2;
                        break;

                    case 'triangles':
                        count = primitive.count * 3;
                        break;

                    case 'polylist':
                        for ( let g = 0; g < primitive.count; g ++ ) {

                            const vc = primitive.vcount[ g ];

                            switch ( vc ) {

                                case 3:
                                    count += 3; // single triangle

                                    break;

                                case 4:
                                    count += 6; // quad, subdivided into two triangles

                                    break;

                                default:
                                    count += ( vc - 2 ) * 3; // polylist with more than four vertices

                                    break;

                            }

                        }

                        break;

                    default:
                        console.warn( 'THREE.ColladaLoader: Unknow primitive type:', primitive.type );

                }

                geometry.addGroup( start, count, p );
                start += count; // material

                if ( primitive.material ) {

                    materialKeys.push( primitive.material );

                } // geometry data


                for ( const name in inputs ) {

                    const input = inputs[ name ];

                    switch ( name ) {

                        case 'VERTEX':
                            for ( const key in vertices ) {

                                const id = vertices[ key ];

                                switch ( key ) {

                                    case 'POSITION':
                                        const prevLength = position.array.length;
                                        buildGeometryData( primitive, sources[ id ], input.offset, position.array );
                                        position.stride = sources[ id ].stride;

                                        if ( sources.skinWeights && sources.skinIndices ) {

                                            buildGeometryData( primitive, sources.skinIndices, input.offset, skinIndex.array );
                                            buildGeometryData( primitive, sources.skinWeights, input.offset, skinWeight.array );

                                        } // see #3803


                                        if ( primitive.hasUV === false && primitives.uvsNeedsFix === true ) {

                                            const count = ( position.array.length - prevLength ) / position.stride;

                                            for ( let i = 0; i < count; i ++ ) {

                                                // fill missing uv coordinates
                                                uv.array.push( 0, 0 );

                                            }

                                        }

                                        break;

                                    case 'NORMAL':
                                        buildGeometryData( primitive, sources[ id ], input.offset, normal.array );
                                        normal.stride = sources[ id ].stride;
                                        break;

                                    case 'COLOR':
                                        buildGeometryData( primitive, sources[ id ], input.offset, color.array );
                                        color.stride = sources[ id ].stride;
                                        break;

                                    case 'TEXCOORD':
                                        buildGeometryData( primitive, sources[ id ], input.offset, uv.array );
                                        uv.stride = sources[ id ].stride;
                                        break;

                                    case 'TEXCOORD1':
                                        buildGeometryData( primitive, sources[ id ], input.offset, uv2.array );
                                        uv.stride = sources[ id ].stride;
                                        break;

                                    default:
                                        console.warn( 'THREE.ColladaLoader: Semantic "%s" not handled in geometry build process.', key );

                                }

                            }

                            break;

                        case 'NORMAL':
                            buildGeometryData( primitive, sources[ input.id ], input.offset, normal.array );
                            normal.stride = sources[ input.id ].stride;
                            break;

                        case 'COLOR':
                            buildGeometryData( primitive, sources[ input.id ], input.offset, color.array, true );
                            color.stride = sources[ input.id ].stride;
                            break;

                        case 'TEXCOORD':
                            buildGeometryData( primitive, sources[ input.id ], input.offset, uv.array );
                            uv.stride = sources[ input.id ].stride;
                            break;

                        case 'TEXCOORD1':
                            buildGeometryData( primitive, sources[ input.id ], input.offset, uv2.array );
                            uv2.stride = sources[ input.id ].stride;
                            break;

                    }

                }

            } // build geometry


            if ( position.array.length > 0 ) geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( position.array, position.stride ) );
            if ( normal.array.length > 0 ) geometry.setAttribute( 'normal', new THREE.Float32BufferAttribute( normal.array, normal.stride ) );
            if ( color.array.length > 0 ) geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( color.array, color.stride ) );
            if ( uv.array.length > 0 ) geometry.setAttribute( 'uv', new THREE.Float32BufferAttribute( uv.array, uv.stride ) );
            if ( uv2.array.length > 0 ) geometry.setAttribute( 'uv2', new THREE.Float32BufferAttribute( uv2.array, uv2.stride ) );
            if ( skinIndex.array.length > 0 ) geometry.setAttribute( 'skinIndex', new THREE.Float32BufferAttribute( skinIndex.array, skinIndex.stride ) );
            if ( skinWeight.array.length > 0 ) geometry.setAttribute( 'skinWeight', new THREE.Float32BufferAttribute( skinWeight.array, skinWeight.stride ) );
            build.data = geometry;
            build.type = primitives[ 0 ].type;
            build.materialKeys = materialKeys;
            return build;

        }

        function buildGeometryData( primitive, source, offset, array, isColor = false ) {

            const indices = primitive.p;
            const stride = primitive.stride;
            const vcount = primitive.vcount;

            function pushVector( i ) {

                let index = indices[ i + offset ] * sourceStride;
                const length = index + sourceStride;

                for ( ; index < length; index ++ ) {

                    array.push( sourceArray[ index ] );

                }

                if ( isColor ) {

                    // convert the vertex colors from srgb to linear if present
                    const startIndex = array.length - sourceStride - 1;
                    tempColor.setRGB( array[ startIndex + 0 ], array[ startIndex + 1 ], array[ startIndex + 2 ] ).convertSRGBToLinear();
                    array[ startIndex + 0 ] = tempColor.r;
                    array[ startIndex + 1 ] = tempColor.g;
                    array[ startIndex + 2 ] = tempColor.b;

                }

            }

            const sourceArray = source.array;
            const sourceStride = source.stride;

            if ( primitive.vcount !== undefined ) {

                let index = 0;

                for ( let i = 0, l = vcount.length; i < l; i ++ ) {

                    const count = vcount[ i ];

                    if ( count === 4 ) {

                        const a = index + stride * 0;
                        const b = index + stride * 1;
                        const c = index + stride * 2;
                        const d = index + stride * 3;
                        pushVector( a );
                        pushVector( b );
                        pushVector( d );
                        pushVector( b );
                        pushVector( c );
                        pushVector( d );

                    } else if ( count === 3 ) {

                        const a = index + stride * 0;
                        const b = index + stride * 1;
                        const c = index + stride * 2;
                        pushVector( a );
                        pushVector( b );
                        pushVector( c );

                    } else if ( count > 4 ) {

                        for ( let k = 1, kl = count - 2; k <= kl; k ++ ) {

                            const a = index + stride * 0;
                            const b = index + stride * k;
                            const c = index + stride * ( k + 1 );
                            pushVector( a );
                            pushVector( b );
                            pushVector( c );

                        }

                    }

                    index += stride * count;

                }

            } else {

                for ( let i = 0, l = indices.length; i < l; i += stride ) {

                    pushVector( i );

                }

            }

        }

        function getGeometry( id ) {

            return getBuild( library.geometries[ id ], buildGeometry );

        } // kinematics


        function parseKinematicsModel( xml ) {

            const data = {
                name: xml.getAttribute( 'name' ) || '',
                joints: {},
                links: []
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'technique_common':
                        parseKinematicsTechniqueCommon( child, data );
                        break;

                }

            }

            library.kinematicsModels[ xml.getAttribute( 'id' ) ] = data;

        }

        function buildKinematicsModel( data ) {

            if ( data.build !== undefined ) return data.build;
            return data;

        }

        function getKinematicsModel( id ) {

            return getBuild( library.kinematicsModels[ id ], buildKinematicsModel );

        }

        function parseKinematicsTechniqueCommon( xml, data ) {

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'joint':
                        data.joints[ child.getAttribute( 'sid' ) ] = parseKinematicsJoint( child );
                        break;

                    case 'link':
                        data.links.push( parseKinematicsLink( child ) );
                        break;

                }

            }

        }

        function parseKinematicsJoint( xml ) {

            let data;

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'prismatic':
                    case 'revolute':
                        data = parseKinematicsJointParameter( child );
                        break;

                }

            }

            return data;

        }

        function parseKinematicsJointParameter( xml ) {

            const data = {
                sid: xml.getAttribute( 'sid' ),
                name: xml.getAttribute( 'name' ) || '',
                axis: new THREE.Vector3(),
                limits: {
                    min: 0,
                    max: 0
                },
                type: xml.nodeName,
                static: false,
                zeroPosition: 0,
                middlePosition: 0
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'axis':
                        const array = parseFloats( child.textContent );
                        data.axis.fromArray( array );
                        break;

                    case 'limits':
                        const max = child.getElementsByTagName( 'max' )[ 0 ];
                        const min = child.getElementsByTagName( 'min' )[ 0 ];
                        data.limits.max = parseFloat( max.textContent );
                        data.limits.min = parseFloat( min.textContent );
                        break;

                }

            } // if min is equal to or greater than max, consider the joint static


            if ( data.limits.min >= data.limits.max ) {

                data.static = true;

            } // calculate middle position


            data.middlePosition = ( data.limits.min + data.limits.max ) / 2.0;
            return data;

        }

        function parseKinematicsLink( xml ) {

            const data = {
                sid: xml.getAttribute( 'sid' ),
                name: xml.getAttribute( 'name' ) || '',
                attachments: [],
                transforms: []
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'attachment_full':
                        data.attachments.push( parseKinematicsAttachment( child ) );
                        break;

                    case 'matrix':
                    case 'translate':
                    case 'rotate':
                        data.transforms.push( parseKinematicsTransform( child ) );
                        break;

                }

            }

            return data;

        }

        function parseKinematicsAttachment( xml ) {

            const data = {
                joint: xml.getAttribute( 'joint' ).split( '/' ).pop(),
                transforms: [],
                links: []
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'link':
                        data.links.push( parseKinematicsLink( child ) );
                        break;

                    case 'matrix':
                    case 'translate':
                    case 'rotate':
                        data.transforms.push( parseKinematicsTransform( child ) );
                        break;

                }

            }

            return data;

        }

        function parseKinematicsTransform( xml ) {

            const data = {
                type: xml.nodeName
            };
            const array = parseFloats( xml.textContent );

            switch ( data.type ) {

                case 'matrix':
                    data.obj = new THREE.Matrix4();
                    data.obj.fromArray( array ).transpose();
                    break;

                case 'translate':
                    data.obj = new THREE.Vector3();
                    data.obj.fromArray( array );
                    break;

                case 'rotate':
                    data.obj = new THREE.Vector3();
                    data.obj.fromArray( array );
                    data.angle = THREE.MathUtils.degToRad( array[ 3 ] );
                    break;

            }

            return data;

        } // physics


        function parsePhysicsModel( xml ) {

            const data = {
                name: xml.getAttribute( 'name' ) || '',
                rigidBodies: {}
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'rigid_body':
                        data.rigidBodies[ child.getAttribute( 'name' ) ] = {};
                        parsePhysicsRigidBody( child, data.rigidBodies[ child.getAttribute( 'name' ) ] );
                        break;

                }

            }

            library.physicsModels[ xml.getAttribute( 'id' ) ] = data;

        }

        function parsePhysicsRigidBody( xml, data ) {

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'technique_common':
                        parsePhysicsTechniqueCommon( child, data );
                        break;

                }

            }

        }

        function parsePhysicsTechniqueCommon( xml, data ) {

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'inertia':
                        data.inertia = parseFloats( child.textContent );
                        break;

                    case 'mass':
                        data.mass = parseFloats( child.textContent )[ 0 ];
                        break;

                }

            }

        } // scene


        function parseKinematicsScene( xml ) {

            const data = {
                bindJointAxis: []
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'bind_joint_axis':
                        data.bindJointAxis.push( parseKinematicsBindJointAxis( child ) );
                        break;

                }

            }

            library.kinematicsScenes[ parseId( xml.getAttribute( 'url' ) ) ] = data;

        }

        function parseKinematicsBindJointAxis( xml ) {

            const data = {
                target: xml.getAttribute( 'target' ).split( '/' ).pop()
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;

                switch ( child.nodeName ) {

                    case 'axis':
                        const param = child.getElementsByTagName( 'param' )[ 0 ];
                        data.axis = param.textContent;
                        const tmpJointIndex = data.axis.split( 'inst_' ).pop().split( 'axis' )[ 0 ];
                        data.jointIndex = tmpJointIndex.substring( 0, tmpJointIndex.length - 1 );
                        break;

                }

            }

            return data;

        }

        function buildKinematicsScene( data ) {

            if ( data.build !== undefined ) return data.build;
            return data;

        }

        function getKinematicsScene( id ) {

            return getBuild( library.kinematicsScenes[ id ], buildKinematicsScene );

        }

        function setupKinematics() {

            const kinematicsModelId = Object.keys( library.kinematicsModels )[ 0 ];
            const kinematicsSceneId = Object.keys( library.kinematicsScenes )[ 0 ];
            const visualSceneId = Object.keys( library.visualScenes )[ 0 ];
            if ( kinematicsModelId === undefined || kinematicsSceneId === undefined ) return;
            const kinematicsModel = getKinematicsModel( kinematicsModelId );
            const kinematicsScene = getKinematicsScene( kinematicsSceneId );
            const visualScene = getVisualScene( visualSceneId );
            const bindJointAxis = kinematicsScene.bindJointAxis;
            const jointMap = {};

            for ( let i = 0, l = bindJointAxis.length; i < l; i ++ ) {

                const axis = bindJointAxis[ i ]; // the result of the following query is an element of type 'translate', 'rotate','scale' or 'matrix'

                const targetElement = collada.querySelector( '[sid="' + axis.target + '"]' );

                if ( targetElement ) {

                    // get the parent of the transform element
                    const parentVisualElement = targetElement.parentElement; // connect the joint of the kinematics model with the element in the visual scene

                    connect( axis.jointIndex, parentVisualElement );

                }

            }

            function connect( jointIndex, visualElement ) {

                const visualElementName = visualElement.getAttribute( 'name' );
                const joint = kinematicsModel.joints[ jointIndex ];
                visualScene.traverse( function ( object ) {

                    if ( object.name === visualElementName ) {

                        jointMap[ jointIndex ] = {
                            object: object,
                            transforms: buildTransformList( visualElement ),
                            joint: joint,
                            position: joint.zeroPosition
                        };

                    }

                } );

            }

            const m0 = new THREE.Matrix4();
            kinematics = {
                joints: kinematicsModel && kinematicsModel.joints,
                getJointValue: function ( jointIndex ) {

                    const jointData = jointMap[ jointIndex ];

                    if ( jointData ) {

                        return jointData.position;

                    } else {

                        console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' doesn\'t exist.' );

                    }

                },
                setJointValue: function ( jointIndex, value ) {

                    const jointData = jointMap[ jointIndex ];

                    if ( jointData ) {

                        const joint = jointData.joint;

                        if ( value > joint.limits.max || value < joint.limits.min ) {

                            console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' value ' + value + ' outside of limits (min: ' + joint.limits.min + ', max: ' + joint.limits.max + ').' );

                        } else if ( joint.static ) {

                            console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' is static.' );

                        } else {

                            const object = jointData.object;
                            const axis = joint.axis;
                            const transforms = jointData.transforms;
                            matrix.identity(); // each update, we have to apply all transforms in the correct order

                            for ( let i = 0; i < transforms.length; i ++ ) {

                                const transform = transforms[ i ]; // if there is a connection of the transform node with a joint, apply the joint value

                                if ( transform.sid && transform.sid.indexOf( jointIndex ) !== - 1 ) {

                                    switch ( joint.type ) {

                                        case 'revolute':
                                            matrix.multiply( m0.makeRotationAxis( axis, THREE.MathUtils.degToRad( value ) ) );
                                            break;

                                        case 'prismatic':
                                            matrix.multiply( m0.makeTranslation( axis.x * value, axis.y * value, axis.z * value ) );
                                            break;

                                        default:
                                            console.warn( 'THREE.ColladaLoader: Unknown joint type: ' + joint.type );
                                            break;

                                    }

                                } else {

                                    switch ( transform.type ) {

                                        case 'matrix':
                                            matrix.multiply( transform.obj );
                                            break;

                                        case 'translate':
                                            matrix.multiply( m0.makeTranslation( transform.obj.x, transform.obj.y, transform.obj.z ) );
                                            break;

                                        case 'scale':
                                            matrix.scale( transform.obj );
                                            break;

                                        case 'rotate':
                                            matrix.multiply( m0.makeRotationAxis( transform.obj, transform.angle ) );
                                            break;

                                    }

                                }

                            }

                            object.matrix.copy( matrix );
                            object.matrix.decompose( object.position, object.quaternion, object.scale );
                            jointMap[ jointIndex ].position = value;

                        }

                    } else {

                        console.log( 'THREE.ColladaLoader: ' + jointIndex + ' does not exist.' );

                    }

                }
            };

        }

        function buildTransformList( node ) {

            const transforms = [];
            const xml = collada.querySelector( '[id="' + node.id + '"]' );

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;
                let array, vector;

                switch ( child.nodeName ) {

                    case 'matrix':
                        array = parseFloats( child.textContent );
                        const matrix = new THREE.Matrix4().fromArray( array ).transpose();
                        transforms.push( {
                            sid: child.getAttribute( 'sid' ),
                            type: child.nodeName,
                            obj: matrix
                        } );
                        break;

                    case 'translate':
                    case 'scale':
                        array = parseFloats( child.textContent );
                        vector = new THREE.Vector3().fromArray( array );
                        transforms.push( {
                            sid: child.getAttribute( 'sid' ),
                            type: child.nodeName,
                            obj: vector
                        } );
                        break;

                    case 'rotate':
                        array = parseFloats( child.textContent );
                        vector = new THREE.Vector3().fromArray( array );
                        const angle = THREE.MathUtils.degToRad( array[ 3 ] );
                        transforms.push( {
                            sid: child.getAttribute( 'sid' ),
                            type: child.nodeName,
                            obj: vector,
                            angle: angle
                        } );
                        break;

                }

            }

            return transforms;

        } // nodes


        function prepareNodes( xml ) {

            const elements = xml.getElementsByTagName( 'node' ); // ensure all node elements have id attributes

            for ( let i = 0; i < elements.length; i ++ ) {

                const element = elements[ i ];

                if ( element.hasAttribute( 'id' ) === false ) {

                    element.setAttribute( 'id', generateId() );

                }

            }

        }

        const matrix = new THREE.Matrix4();
        const vector = new THREE.Vector3();

        function parseNode( xml ) {

            const data = {
                name: xml.getAttribute( 'name' ) || '',
                type: xml.getAttribute( 'type' ),
                id: xml.getAttribute( 'id' ),
                sid: xml.getAttribute( 'sid' ),
                matrix: new THREE.Matrix4(),
                nodes: [],
                instanceCameras: [],
                instanceControllers: [],
                instanceLights: [],
                instanceGeometries: [],
                instanceNodes: [],
                transforms: {}
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];
                if ( child.nodeType !== 1 ) continue;
                let array;

                switch ( child.nodeName ) {

                    case 'node':
                        data.nodes.push( child.getAttribute( 'id' ) );
                        parseNode( child );
                        break;

                    case 'instance_camera':
                        data.instanceCameras.push( parseId( child.getAttribute( 'url' ) ) );
                        break;

                    case 'instance_controller':
                        data.instanceControllers.push( parseNodeInstance( child ) );
                        break;

                    case 'instance_light':
                        data.instanceLights.push( parseId( child.getAttribute( 'url' ) ) );
                        break;

                    case 'instance_geometry':
                        data.instanceGeometries.push( parseNodeInstance( child ) );
                        break;

                    case 'instance_node':
                        data.instanceNodes.push( parseId( child.getAttribute( 'url' ) ) );
                        break;

                    case 'matrix':
                        array = parseFloats( child.textContent );
                        data.matrix.multiply( matrix.fromArray( array ).transpose() );
                        data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
                        break;

                    case 'translate':
                        array = parseFloats( child.textContent );
                        vector.fromArray( array );
                        data.matrix.multiply( matrix.makeTranslation( vector.x, vector.y, vector.z ) );
                        data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
                        break;

                    case 'rotate':
                        array = parseFloats( child.textContent );
                        const angle = THREE.MathUtils.degToRad( array[ 3 ] );
                        data.matrix.multiply( matrix.makeRotationAxis( vector.fromArray( array ), angle ) );
                        data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
                        break;

                    case 'scale':
                        array = parseFloats( child.textContent );
                        data.matrix.scale( vector.fromArray( array ) );
                        data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
                        break;

                    case 'extra':
                        break;

                    default:
                        console.log( child );

                }

            }

            if ( hasNode( data.id ) ) {

                console.warn( 'THREE.ColladaLoader: There is already a node with ID %s. Exclude current node from further processing.', data.id );

            } else {

                library.nodes[ data.id ] = data;

            }

            return data;

        }

        function parseNodeInstance( xml ) {

            const data = {
                id: parseId( xml.getAttribute( 'url' ) ),
                materials: {},
                skeletons: []
            };

            for ( let i = 0; i < xml.childNodes.length; i ++ ) {

                const child = xml.childNodes[ i ];

                switch ( child.nodeName ) {

                    case 'bind_material':
                        const instances = child.getElementsByTagName( 'instance_material' );

                        for ( let j = 0; j < instances.length; j ++ ) {

                            const instance = instances[ j ];
                            const symbol = instance.getAttribute( 'symbol' );
                            const target = instance.getAttribute( 'target' );
                            data.materials[ symbol ] = parseId( target );

                        }

                        break;

                    case 'skeleton':
                        data.skeletons.push( parseId( child.textContent ) );
                        break;

                    default:
                        break;

                }

            }

            return data;

        }

        function buildSkeleton( skeletons, joints ) {

            const boneData = [];
            const sortedBoneData = [];
            let i, j, data; // a skeleton can have multiple root bones. collada expresses this
            // situtation with multiple "skeleton" tags per controller instance

            for ( i = 0; i < skeletons.length; i ++ ) {

                const skeleton = skeletons[ i ];
                let root;

                if ( hasNode( skeleton ) ) {

                    root = getNode( skeleton );
                    buildBoneHierarchy( root, joints, boneData );

                } else if ( hasVisualScene( skeleton ) ) {

                    // handle case where the skeleton refers to the visual scene (#13335)
                    const visualScene = library.visualScenes[ skeleton ];
                    const children = visualScene.children;

                    for ( let j = 0; j < children.length; j ++ ) {

                        const child = children[ j ];

                        if ( child.type === 'JOINT' ) {

                            const root = getNode( child.id );
                            buildBoneHierarchy( root, joints, boneData );

                        }

                    }

                } else {

                    console.error( 'THREE.ColladaLoader: Unable to find root bone of skeleton with ID:', skeleton );

                }

            } // sort bone data (the order is defined in the corresponding controller)


            for ( i = 0; i < joints.length; i ++ ) {

                for ( j = 0; j < boneData.length; j ++ ) {

                    data = boneData[ j ];

                    if ( data.bone.name === joints[ i ].name ) {

                        sortedBoneData[ i ] = data;
                        data.processed = true;
                        break;

                    }

                }

            } // add unprocessed bone data at the end of the list


            for ( i = 0; i < boneData.length; i ++ ) {

                data = boneData[ i ];

                if ( data.processed === false ) {

                    sortedBoneData.push( data );
                    data.processed = true;

                }

            } // setup arrays for skeleton creation


            const bones = [];
            const boneInverses = [];

            for ( i = 0; i < sortedBoneData.length; i ++ ) {

                data = sortedBoneData[ i ];
                bones.push( data.bone );
                boneInverses.push( data.boneInverse );

            }

            return new THREE.Skeleton( bones, boneInverses );

        }

        function buildBoneHierarchy( root, joints, boneData ) {

            // setup bone data from visual scene
            root.traverse( function ( object ) {

                if ( object.isBone === true ) {

                    let boneInverse; // retrieve the boneInverse from the controller data

                    for ( let i = 0; i < joints.length; i ++ ) {

                        const joint = joints[ i ];

                        if ( joint.name === object.name ) {

                            boneInverse = joint.boneInverse;
                            break;

                        }

                    }

                    if ( boneInverse === undefined ) {

                        // Unfortunately, there can be joints in the visual scene that are not part of the
                        // corresponding controller. In this case, we have to create a dummy boneInverse matrix
                        // for the respective bone. This bone won't affect any vertices, because there are no skin indices
                        // and weights defined for it. But we still have to add the bone to the sorted bone list in order to
                        // ensure a correct animation of the model.
                        boneInverse = new THREE.Matrix4();

                    }

                    boneData.push( {
                        bone: object,
                        boneInverse: boneInverse,
                        processed: false
                    } );

                }

            } );

        }

        function buildNode( data ) {

            const objects = [];
            const matrix = data.matrix;
            const nodes = data.nodes;
            const type = data.type;
            const instanceCameras = data.instanceCameras;
            const instanceControllers = data.instanceControllers;
            const instanceLights = data.instanceLights;
            const instanceGeometries = data.instanceGeometries;
            const instanceNodes = data.instanceNodes; // nodes

            for ( let i = 0, l = nodes.length; i < l; i ++ ) {

                objects.push( getNode( nodes[ i ] ) );

            } // instance cameras


            for ( let i = 0, l = instanceCameras.length; i < l; i ++ ) {

                const instanceCamera = getCamera( instanceCameras[ i ] );

                if ( instanceCamera !== null ) {

                    objects.push( instanceCamera.clone() );

                }

            } // instance controllers


            for ( let i = 0, l = instanceControllers.length; i < l; i ++ ) {

                const instance = instanceControllers[ i ];
                const controller = getController( instance.id );
                const geometries = getGeometry( controller.id );
                const newObjects = buildObjects( geometries, instance.materials );
                const skeletons = instance.skeletons;
                const joints = controller.skin.joints;
                const skeleton = buildSkeleton( skeletons, joints );

                for ( let j = 0, jl = newObjects.length; j < jl; j ++ ) {

                    const object = newObjects[ j ];

                    if ( object.isSkinnedMesh ) {

                        object.bind( skeleton, controller.skin.bindMatrix );
                        object.normalizeSkinWeights();

                    }

                    objects.push( object );

                }

            } // instance lights


            for ( let i = 0, l = instanceLights.length; i < l; i ++ ) {

                const instanceLight = getLight( instanceLights[ i ] );

                if ( instanceLight !== null ) {

                    objects.push( instanceLight.clone() );

                }

            } // instance geometries


            for ( let i = 0, l = instanceGeometries.length; i < l; i ++ ) {

                const instance = instanceGeometries[ i ]; // a single geometry instance in collada can lead to multiple object3Ds.
                // this is the case when primitives are combined like triangles and lines

                const geometries = getGeometry( instance.id );
                const newObjects = buildObjects( geometries, instance.materials );

                for ( let j = 0, jl = newObjects.length; j < jl; j ++ ) {

                    objects.push( newObjects[ j ] );

                }

            } // instance nodes


            for ( let i = 0, l = instanceNodes.length; i < l; i ++ ) {

                objects.push( getNode( instanceNodes[ i ] ).clone() );

            }

            let object;

            if ( nodes.length === 0 && objects.length === 1 ) {

                object = objects[ 0 ];

            } else {

                object = type === 'JOINT' ? new THREE.Bone() : new THREE.Group();

                for ( let i = 0; i < objects.length; i ++ ) {

                    object.add( objects[ i ] );

                }

            }

            object.name = type === 'JOINT' ? data.sid : data.name;
            object.matrix.copy( matrix );
            object.matrix.decompose( object.position, object.quaternion, object.scale );
            return object;

        }

        const fallbackMaterial = new THREE.MeshBasicMaterial( {
            color: 0xff00ff
        } );

        function resolveMaterialBinding( keys, instanceMaterials ) {

            const materials = [];

            for ( let i = 0, l = keys.length; i < l; i ++ ) {

                const id = instanceMaterials[ keys[ i ] ];

                if ( id === undefined ) {

                    console.warn( 'THREE.ColladaLoader: Material with key %s not found. Apply fallback material.', keys[ i ] );
                    materials.push( fallbackMaterial );

                } else {

                    materials.push( getMaterial( id ) );

                }

            }

            return materials;

        }

        function buildObjects( geometries, instanceMaterials ) {

            const objects = [];

            for ( const type in geometries ) {

                const geometry = geometries[ type ];
                const materials = resolveMaterialBinding( geometry.materialKeys, instanceMaterials ); // handle case if no materials are defined

                if ( materials.length === 0 ) {

                    if ( type === 'lines' || type === 'linestrips' ) {

                        materials.push( new THREE.LineBasicMaterial() );

                    } else {

                        materials.push( new THREE.MeshPhongMaterial() );

                    }

                } // regard skinning


                const skinning = geometry.data.attributes.skinIndex !== undefined; // choose between a single or multi materials (material array)

                const material = materials.length === 1 ? materials[ 0 ] : materials; // now create a specific 3D object

                let object;

                switch ( type ) {

                    case 'lines':
                        object = new THREE.LineSegments( geometry.data, material );
                        break;

                    case 'linestrips':
                        object = new THREE.Line( geometry.data, material );
                        break;

                    case 'triangles':
                    case 'polylist':
                        if ( skinning ) {

                            object = new THREE.SkinnedMesh( geometry.data, material );

                        } else {

                            object = new THREE.Mesh( geometry.data, material );

                        }

                        break;

                }

                objects.push( object );

            }

            return objects;

        }

        function hasNode( id ) {

            return library.nodes[ id ] !== undefined;

        }

        function getNode( id ) {

            return getBuild( library.nodes[ id ], buildNode );

        } // visual scenes


        function parseVisualScene( xml ) {

            const data = {
                name: xml.getAttribute( 'name' ),
                children: []
            };
            prepareNodes( xml );
            const elements = getElementsByTagName( xml, 'node' );

            for ( let i = 0; i < elements.length; i ++ ) {

                data.children.push( parseNode( elements[ i ] ) );

            }

            library.visualScenes[ xml.getAttribute( 'id' ) ] = data;

        }

        function buildVisualScene( data ) {

            const group = new THREE.Group();
            group.name = data.name;
            const children = data.children;

            for ( let i = 0; i < children.length; i ++ ) {

                const child = children[ i ];
                group.add( getNode( child.id ) );

            }

            return group;

        }

        function hasVisualScene( id ) {

            return library.visualScenes[ id ] !== undefined;

        }

        function getVisualScene( id ) {

            return getBuild( library.visualScenes[ id ], buildVisualScene );

        } // scenes


        function parseScene( xml ) {

            const instance = getElementsByTagName( xml, 'instance_visual_scene' )[ 0 ];
            return getVisualScene( parseId( instance.getAttribute( 'url' ) ) );

        }

        function setupAnimations() {

            const clips = library.clips;

            if ( isEmpty( clips ) === true ) {

                if ( isEmpty( library.animations ) === false ) {

                    // if there are animations but no clips, we create a default clip for playback
                    const tracks = [];

                    for ( const id in library.animations ) {

                        const animationTracks = getAnimation( id );

                        for ( let i = 0, l = animationTracks.length; i < l; i ++ ) {

                            tracks.push( animationTracks[ i ] );

                        }

                    }

                    animations.push( new THREE.AnimationClip( 'default', - 1, tracks ) );

                }

            } else {

                for ( const id in clips ) {

                    animations.push( getAnimationClip( id ) );

                }

            }

        } // convert the parser error element into text with each child elements text
        // separated by new lines.


        function parserErrorToText( parserError ) {

            let result = '';
            const stack = [ parserError ];

            while ( stack.length ) {

                const node = stack.shift();

                if ( node.nodeType === Node.TEXT_NODE ) {

                    result += node.textContent;

                } else {

                    result += '\n';
                    stack.push.apply( stack, node.childNodes );

                }

            }

            return result.trim();

        }

        if ( text.length === 0 ) {

            return {
                scene: new THREE.Scene()
            };

        }

        const xml = new DOMParser().parseFromString( text, 'application/xml' );
        const collada = getElementsByTagName( xml, 'COLLADA' )[ 0 ];
        const parserError = xml.getElementsByTagName( 'parsererror' )[ 0 ];

        if ( parserError !== undefined ) {

            // Chrome will return parser error with a div in it
            const errorElement = getElementsByTagName( parserError, 'div' )[ 0 ];
            let errorText;

            if ( errorElement ) {

                errorText = errorElement.textContent;

            } else {

                errorText = parserErrorToText( parserError );

            }

            console.error( 'THREE.ColladaLoader: Failed to parse collada file.\n', errorText );
            return null;

        } // metadata


        const version = collada.getAttribute( 'version' );
        console.log( 'THREE.ColladaLoader: File version', version );
        const asset = parseAsset( getElementsByTagName( collada, 'asset' )[ 0 ] );
        const textureLoader = new THREE.TextureLoader( this.manager );
        textureLoader.setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
        let tgaLoader;

        if ( THREE.TGALoader ) {

            tgaLoader = new THREE.TGALoader( this.manager );
            tgaLoader.setPath( this.resourcePath || path );

        } //


        const tempColor = new THREE.Color();
        const animations = [];
        let kinematics = {};
        let count = 0; //

        const library = {
            animations: {},
            clips: {},
            controllers: {},
            images: {},
            effects: {},
            materials: {},
            cameras: {},
            lights: {},
            geometries: {},
            nodes: {},
            visualScenes: {},
            kinematicsModels: {},
            physicsModels: {},
            kinematicsScenes: {}
        };
        parseLibrary( collada, 'library_animations', 'animation', parseAnimation );
        parseLibrary( collada, 'library_animation_clips', 'animation_clip', parseAnimationClip );
        parseLibrary( collada, 'library_controllers', 'controller', parseController );
        parseLibrary( collada, 'library_images', 'image', parseImage );
        parseLibrary( collada, 'library_effects', 'effect', parseEffect );
        parseLibrary( collada, 'library_materials', 'material', parseMaterial );
        parseLibrary( collada, 'library_cameras', 'camera', parseCamera );
        parseLibrary( collada, 'library_lights', 'light', parseLight );
        parseLibrary( collada, 'library_geometries', 'geometry', parseGeometry );
        parseLibrary( collada, 'library_nodes', 'node', parseNode );
        parseLibrary( collada, 'library_visual_scenes', 'visual_scene', parseVisualScene );
        parseLibrary( collada, 'library_kinematics_models', 'kinematics_model', parseKinematicsModel );
        parseLibrary( collada, 'library_physics_models', 'physics_model', parsePhysicsModel );
        parseLibrary( collada, 'scene', 'instance_kinematics_scene', parseKinematicsScene );
        buildLibrary( library.animations, buildAnimation );
        buildLibrary( library.clips, buildAnimationClip );
        buildLibrary( library.controllers, buildController );
        buildLibrary( library.images, buildImage );
        buildLibrary( library.effects, buildEffect );
        buildLibrary( library.materials, buildMaterial );
        buildLibrary( library.cameras, buildCamera );
        buildLibrary( library.lights, buildLight );
        buildLibrary( library.geometries, buildGeometry );
        buildLibrary( library.visualScenes, buildVisualScene );
        setupAnimations();
        setupKinematics();
        const scene = parseScene( getElementsByTagName( collada, 'scene' )[ 0 ] );
        scene.animations = animations;

        if ( asset.upAxis === 'Z_UP' ) {

            scene.quaternion.setFromEuler( new THREE.Euler( - Math.PI / 2, 0, 0 ) );

        }

        scene.scale.multiplyScalar( asset.unit );
        return {
            get animations() {

                console.warn( 'THREE.ColladaLoader: Please access animations over scene.animations now.' );
                return animations;

            },

            kinematics: kinematics,
            library: library,
            scene: scene
        };

    }

}